home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 January: Mac OS SDK / Dev.CD Jan 99 SDK1.toast / Development Kits / Interfaces&Libraries / Universal / Interfaces / CIncludes / OCEMessaging.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-17  |  31.0 KB  |  1,120 lines  |  [TEXT/MPS ]
  1. /*
  2.      File:        OCEMessaging.h
  3.  
  4.      Contains:    Apple Open Collaboration Environment Messaging Interfaces.
  5.  
  6.      Version:    Technology:    AOCE Toolbox 1.02
  7.                  Release:    Universal Interfaces 3.2
  8.  
  9.      Copyright:    © 1994-1998 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  17. #ifndef __OCEMESSAGING__
  18. #define __OCEMESSAGING__
  19.  
  20. #ifndef __FILES__
  21. #include <Files.h>
  22. #endif
  23. #ifndef __MACTYPES__
  24. #include <MacTypes.h>
  25. #endif
  26.  
  27. #ifndef __DIGITALSIGNATURE__
  28. #include <DigitalSignature.h>
  29. #endif
  30. #ifndef __OCE__
  31. #include <OCE.h>
  32. #endif
  33. #ifndef __OCEAUTHDIR__
  34. #include <OCEAuthDir.h>
  35. #endif
  36.  
  37.  
  38.  
  39. #if PRAGMA_ONCE
  40. #pragma once
  41. #endif
  42.  
  43. #ifdef __cplusplus
  44. extern "C" {
  45. #endif
  46.  
  47. #if PRAGMA_IMPORT
  48. #pragma import on
  49. #endif
  50.  
  51. #if PRAGMA_STRUCT_ALIGN
  52.     #pragma options align=mac68k
  53. #elif PRAGMA_STRUCT_PACKPUSH
  54.     #pragma pack(push, 2)
  55. #elif PRAGMA_STRUCT_PACK
  56.     #pragma pack(2)
  57. #endif
  58.  
  59. /******************************************************************************/
  60. /* Definitions common to OCEMessaging and to OCEMail. These relate to addressing,
  61. message ids and priorities, etc. */
  62.  
  63. /* Values of IPMPriority */
  64.  
  65. enum {
  66.     kIPMAnyPriority                = 0,                            /* FOR FILTER ONLY */
  67.     kIPMNormalPriority            = 1,
  68.     kIPMLowPriority                = 2,
  69.     kIPMHighPriority            = 3
  70. };
  71.  
  72. typedef Byte                             IPMPriority;
  73. /* Values of IPMAccessMode */
  74.  
  75. enum {
  76.     kIPMAtMark                    = 0,
  77.     kIPMFromStart                = 1,
  78.     kIPMFromLEOM                = 2,
  79.     kIPMFromMark                = 3
  80. };
  81.  
  82. typedef unsigned short                     IPMAccessMode;
  83.  
  84. enum {
  85.     kIPMUpdateMsgBit            = 4,
  86.     kIPMNewMsgBit                = 5,
  87.     kIPMDeleteMsgBit            = 6
  88. };
  89.  
  90. /* Values of IPMNotificationType */
  91.  
  92. enum {
  93.     kIPMUpdateMsgMask            = 1 << kIPMUpdateMsgBit,
  94.     kIPMNewMsgMask                = 1 << kIPMNewMsgBit,
  95.     kIPMDeleteMsgMask            = 1 << kIPMDeleteMsgBit
  96. };
  97.  
  98. typedef Byte                             IPMNotificationType;
  99. /* Values of IPMSenderTag */
  100.  
  101. enum {
  102.     kIPMSenderRStringTag        = 0,
  103.     kIPMSenderRecordIDTag        = 1
  104. };
  105.  
  106. typedef unsigned short                     IPMSenderTag;
  107.  
  108. enum {
  109.     kIPMFromDistListBit            = 0,
  110.     kIPMDummyRecBit                = 1,
  111.     kIPMFeedbackRecBit            = 2,                            /* should be redirected to feedback queue */
  112.     kIPMReporterRecBit            = 3,                            /* should be redirected to reporter original queue */
  113.     kIPMBCCRecBit                = 4                                /* this recipient is blind to all recipients of message */
  114. };
  115.  
  116. /* Values of OCERecipientOffsetFlags */
  117.  
  118. enum {
  119.     kIPMFromDistListMask        = 1 << kIPMFromDistListBit,
  120.     kIPMDummyRecMask            = 1 << kIPMDummyRecBit,
  121.     kIPMFeedbackRecMask            = 1 << kIPMFeedbackRecBit,
  122.     kIPMReporterRecMask            = 1 << kIPMReporterRecBit,
  123.     kIPMBCCRecMask                = 1 << kIPMBCCRecBit
  124. };
  125.  
  126. typedef Byte                             OCERecipientOffsetFlags;
  127.  
  128. struct OCECreatorType {
  129.     OSType                             msgCreator;
  130.     OSType                             msgType;
  131. };
  132. typedef struct OCECreatorType            OCECreatorType;
  133.  
  134. enum {
  135.     kIPMTypeWildCard            = FOUR_CHAR_CODE('ipmw'),
  136.     kIPMFamilyUnspecified        = 0,
  137.     kIPMFamilyWildCard            = 0x3F3F3F3F,                    /* '????' * well known signature */
  138.     kIPMSignature                = FOUR_CHAR_CODE('ipms'),        /* base type * well known message types */
  139.     kIPMReportNotify            = FOUR_CHAR_CODE('rptn'),        /* routing feedback * well known message block types */
  140.     kIPMEnclosedMsgType            = FOUR_CHAR_CODE('emsg'),        /* enclosed (nested) message */
  141.     kIPMReportInfo                = FOUR_CHAR_CODE('rpti'),        /* recipient information */
  142.     kIPMDigitalSignature        = FOUR_CHAR_CODE('dsig')        /* digital signature */
  143. };
  144.  
  145. /* Values of IPMMsgFormat */
  146.  
  147. enum {
  148.     kIPMOSFormatType            = 1,
  149.     kIPMStringFormatType        = 2
  150. };
  151.  
  152.  
  153. typedef unsigned short                     IPMMsgFormat;
  154. typedef Str32                             IPMStringMsgType;
  155.  
  156. union TheType {
  157.     OCECreatorType                     msgOSType;
  158.     IPMStringMsgType                 msgStrType;
  159. };
  160. typedef union TheType                    TheType;
  161.  
  162. struct IPMMsgType {
  163.     IPMMsgFormat                     format;                        /* IPMMsgFormat*/
  164.     TheType                         theType;
  165. };
  166. typedef struct IPMMsgType                IPMMsgType;
  167. /*
  168. Following are the known extension values for IPM addresses handled by Apple.
  169. We define the definition of the entn extension below.
  170. */
  171.  
  172. enum {
  173.     kOCEalanXtn                    = FOUR_CHAR_CODE('alan'),
  174.     kOCEentnXtn                    = FOUR_CHAR_CODE('entn'),        /* entn = entity name (aka DSSpec) */
  175.     kOCEaphnXtn                    = FOUR_CHAR_CODE('aphn')
  176. };
  177.  
  178. /*
  179. Following are the specific definitions for the extension for the standard
  180. OCEMail 'entn' addresses.  [Note, the actual extension is formatted as in
  181. IPMEntityNameExtension.]
  182. */
  183. /* entn extension forms */
  184.  
  185. enum {
  186.     kOCEAddrXtn                    = FOUR_CHAR_CODE('addr'),
  187.     kOCEQnamXtn                    = FOUR_CHAR_CODE('qnam'),
  188.     kOCEAttrXtn                    = FOUR_CHAR_CODE('attr'),        /* an attribute specification */
  189.     kOCESpAtXtn                    = FOUR_CHAR_CODE('spat')        /* specific attribute */
  190. };
  191.  
  192. /*
  193. Following are the specific definitions for standard
  194. OCEMail 'aphn' extension value.  
  195.  
  196. All RStrings here are packed (e.g. truncated to length) and even padded (e.g.
  197. if length odd, then a pad byte (zero) should be introduced before the next field).
  198.  
  199. The extension value is in the packed form of the following structure:
  200.     RString        phoneNumber;
  201.     RString        modemType;
  202.     Str32        queueuName;
  203.  
  204. The body of phoneNumber compound RString is in the packed form of the following structure:
  205.     short         subType;
  206.     RString     countryCode;                // used when subType == kOCEUseHandyDial
  207.     RString        areaCode;                    // used when subType == kOCEUseHandyDial
  208.     RString        phone;                        // used when subType == kOCEUseHandyDial
  209.     RString        postFix;                    // used when subType == kOCEUseHandyDial
  210.     RString        nonHandyDialString;            // used when subType == kOCEDontUseHandyDial
  211. */
  212. /* phoneNumber sub type constants */
  213.  
  214. enum {
  215.     kOCEUseHandyDial            = 1,
  216.     kOCEDontUseHandyDial        = 2
  217. };
  218.  
  219. /* FORMAT OF A PACKED FORM RECIPIENT */
  220.  
  221. struct ProtoOCEPackedRecipient {
  222.     unsigned short                     dataLength;
  223. };
  224. typedef struct ProtoOCEPackedRecipient    ProtoOCEPackedRecipient;
  225.  
  226. enum {
  227.     kOCEPackedRecipientMaxBytes    = (4096 - sizeof(ProtoOCEPackedRecipient))
  228. };
  229.  
  230.  
  231. struct OCEPackedRecipient {
  232.     unsigned short                     dataLength;
  233.     Byte                             data[4094];
  234. };
  235. typedef struct OCEPackedRecipient        OCEPackedRecipient;
  236.  
  237. struct IPMEntnQueueExtension {
  238.     Str32                             queueName;
  239. };
  240. typedef struct IPMEntnQueueExtension    IPMEntnQueueExtension;
  241. /* kOCEAttrXtn */
  242.  
  243. struct IPMEntnAttributeExtension {
  244.     AttributeType                     attributeName;
  245. };
  246. typedef struct IPMEntnAttributeExtension IPMEntnAttributeExtension;
  247. /* kOCESpAtXtn */
  248.  
  249. struct IPMEntnSpecificAttributeExtension {
  250.     AttributeCreationID             attributeCreationID;
  251.     AttributeType                     attributeName;
  252. };
  253. typedef struct IPMEntnSpecificAttributeExtension IPMEntnSpecificAttributeExtension;
  254. /* All IPM entn extensions fit within the following */
  255.  
  256. struct IPMEntityNameExtension {
  257.     OSType                             subExtensionType;
  258.     union {
  259.         IPMEntnSpecificAttributeExtension  specificAttribute;
  260.         IPMEntnAttributeExtension         attribute;
  261.         IPMEntnQueueExtension             queue;
  262.     }                                 u;
  263. };
  264. typedef struct IPMEntityNameExtension    IPMEntityNameExtension;
  265. /* addresses with kIPMNBPXtn should specify this nbp type */
  266. #define kIPMWSReceiverNBPType "\pMsgReceiver" 
  267.  
  268. struct IPMMsgID {
  269.     unsigned long                     id[4];
  270. };
  271. typedef struct IPMMsgID                    IPMMsgID;
  272.  
  273. /* Values of IPMHeaderSelector */
  274.  
  275. enum {
  276.     kIPMTOC                        = 0,
  277.     kIPMSender                    = 1,
  278.     kIPMProcessHint                = 2,
  279.     kIPMMessageTitle            = 3,
  280.     kIPMMessageType                = 4,
  281.     kIPMFixedInfo                = 7
  282. };
  283.  
  284.  
  285. typedef Byte                             IPMHeaderSelector;
  286.  
  287. union TheSender {
  288.     RString                         rString;
  289.     PackedRecordID                     rid;
  290. };
  291. typedef union TheSender                    TheSender;
  292.  
  293. struct IPMSender {
  294.     IPMSenderTag                     sendTag;
  295.     TheSender                         theSender;
  296. };
  297. typedef struct IPMSender                IPMSender;
  298. /******************************************************************************/
  299. /* Definitions specific to OCEMessaging */
  300.  
  301. typedef unsigned long                     IPMContextRef;
  302. typedef unsigned long                     IPMQueueRef;
  303. typedef unsigned long                     IPMMsgRef;
  304. typedef unsigned long                     IPMSeqNum;
  305. typedef Str32                             IPMProcHint;
  306. typedef Str32                             IPMQueueName;
  307. typedef CALLBACK_API( void , IPMNoteProcPtr )(IPMQueueRef queue, IPMSeqNum seqNum, IPMNotificationType notificationType, unsigned long userData);
  308. typedef STACK_UPP_TYPE(IPMNoteProcPtr)                             IPMNoteUPP;
  309. enum { uppIPMNoteProcInfo = 0x000037C0 };                         /* pascal no_return_value Func(4_bytes, 4_bytes, 1_byte, 4_bytes) */
  310. #define NewIPMNoteProc(userRoutine)                             (IPMNoteUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppIPMNoteProcInfo, GetCurrentArchitecture())
  311. #define CallIPMNoteProc(userRoutine, queue, seqNum, notificationType, userData)  CALL_FOUR_PARAMETER_UPP((userRoutine), uppIPMNoteProcInfo, (queue), (seqNum), (notificationType), (userData))
  312.  
  313. struct IPMFixedHdrInfo {
  314.     unsigned short                     version;
  315.     Boolean                         authenticated;
  316.     Boolean                         signatureEnclosed;            /*  digital signature enclosed */
  317.     unsigned long                     msgSize;
  318.     IPMNotificationType             notification;
  319.     IPMPriority                     priority;
  320.     unsigned short                     blockCount;
  321.     unsigned short                     originalRcptCount;            /*        original number of recipients */
  322.     unsigned long                     refCon;                        /*        Client defined data */
  323.     unsigned short                     reserved;
  324.     UTCTime                         creationTime;                /*        Time when it was created */
  325.     IPMMsgID                         msgID;
  326.     OSType                             family;                        /* family this msg belongs (e.g. mail) */
  327. };
  328. typedef struct IPMFixedHdrInfo            IPMFixedHdrInfo;
  329.  
  330. enum {
  331.     kIPMDeliveryNotificationBit    = 0,
  332.     kIPMNonDeliveryNotificationBit = 1,
  333.     kIPMEncloseOriginalBit        = 2,
  334.     kIPMSummaryReportBit        = 3,                            /* modify enclose original to only on error */
  335.     kIPMOriginalOnlyOnErrorBit    = 4
  336. };
  337.  
  338.  
  339. enum {
  340.     kIPMNoNotificationMask        = 0x00,
  341.     kIPMDeliveryNotificationMask = 1 << kIPMDeliveryNotificationBit,
  342.     kIPMNonDeliveryNotificationMask = 1 << kIPMNonDeliveryNotificationBit,
  343.     kIPMDontEncloseOriginalMask    = 0x00,
  344.     kIPMEncloseOriginalMask        = 1 << kIPMEncloseOriginalBit,
  345.     kIPMImmediateReportMask        = 0x00,
  346.     kIPMSummaryReportMask        = 1 << kIPMSummaryReportBit,
  347.     kIPMOriginalOnlyOnErrorMask    = 1 << kIPMOriginalOnlyOnErrorBit,
  348.     kIPMEncloseOriginalOnErrorMask = (kIPMOriginalOnlyOnErrorMask | kIPMEncloseOriginalMask)
  349. };
  350.  
  351. /* standard Non delivery codes */
  352.  
  353. enum {
  354.     kIPMNoSuchRecipient            = 0x0001,
  355.     kIPMRecipientMalformed        = 0x0002,
  356.     kIPMRecipientAmbiguous        = 0x0003,
  357.     kIPMRecipientAccessDenied    = 0x0004,
  358.     kIPMGroupExpansionProblem    = 0x0005,
  359.     kIPMMsgUnreadable            = 0x0006,
  360.     kIPMMsgExpired                = 0x0007,
  361.     kIPMMsgNoTranslatableContent = 0x0008,
  362.     kIPMRecipientReqStdCont        = 0x0009,
  363.     kIPMRecipientReqSnapShot    = 0x000A,
  364.     kIPMNoTransferDiskFull        = 0x000B,
  365.     kIPMNoTransferMsgRejectedbyDest = 0x000C,
  366.     kIPMNoTransferMsgTooLarge    = 0x000D
  367. };
  368.  
  369. /*************************************************************************/
  370. /*
  371. This is the structure that will be returned by enumerate and getmsginfo
  372. This definition is just to give you a template, the position of msgType
  373. is variable since this is a packed structure.  procHint and msgType are
  374. packed and even length padded.
  375.  
  376. * master message info */
  377.  
  378. struct IPMMsgInfo {
  379.     IPMSeqNum                         sequenceNum;
  380.     unsigned long                     userData;
  381.     unsigned short                     respIndex;
  382.     SInt8                             padByte;
  383.     IPMPriority                     priority;
  384.     unsigned long                     msgSize;
  385.     unsigned short                     originalRcptCount;
  386.     unsigned short                     reserved;
  387.     UTCTime                         creationTime;
  388.     IPMMsgID                         msgID;
  389.     OSType                             family;                        /* family this msg belongs (e.g. mail) */
  390.     IPMProcHint                     procHint;
  391.     SInt8                             filler2;
  392.     IPMMsgType                         msgType;
  393. };
  394. typedef struct IPMMsgInfo                IPMMsgInfo;
  395.  
  396. typedef OCECreatorType                     IPMBlockType;
  397.  
  398. struct IPMTOC {
  399.     IPMBlockType                     blockType;
  400.     long                             blockOffset;
  401.     unsigned long                     blockSize;
  402.     unsigned long                     blockRefCon;
  403. };
  404. typedef struct IPMTOC                    IPMTOC;
  405. /*
  406. The following structure is just to describe the layout of the SingleFilter.
  407. Each field should be packed and word aligned when passed to the IPM ToolBox.
  408. */
  409.  
  410. struct IPMSingleFilter {
  411.     IPMPriority                     priority;
  412.     SInt8                             padByte;
  413.     OSType                             family;                        /* family this msg belongs (e.g. mail), '????' for all */
  414.     ScriptCode                         script;                        /* Language Identifier */
  415.     IPMProcHint                     hint;
  416.     SInt8                             filler2;
  417.     IPMMsgType                         msgType;
  418. };
  419. typedef struct IPMSingleFilter            IPMSingleFilter;
  420.  
  421. struct IPMFilter {
  422.     unsigned short                     count;
  423.     IPMSingleFilter                 sFilters[1];
  424. };
  425. typedef struct IPMFilter                IPMFilter;
  426. /*************************************************************************
  427. Following structures define the “start” of a recipient report block and the
  428. elements of the array respectively.
  429. */
  430.  
  431. struct IPMReportBlockHeader {
  432.     IPMMsgID                         msgID;                        /* message id of the original */
  433.     UTCTime                         creationTime;                /* creation time of the report */
  434. };
  435. typedef struct IPMReportBlockHeader        IPMReportBlockHeader;
  436.  
  437. struct OCERecipientReport {
  438.     unsigned short                     rcptIndex;                    /* index of recipient in original message */
  439.     OSErr                             result;                        /* result of sending letter to this recipient*/
  440. };
  441. typedef struct OCERecipientReport        OCERecipientReport;
  442. /*************************************************************************/
  443. typedef union IPMParamBlock             IPMParamBlock;
  444.  
  445. typedef IPMParamBlock *                    IPMParamBlockPtr;
  446. typedef CALLBACK_API( void , IPMIOCompletionProcPtr )(IPMParamBlockPtr paramBlock);
  447. /*
  448.     WARNING: IPMIOCompletionProcPtr uses register based parameters under classic 68k
  449.              and cannot be written in a high-level language without 
  450.              the help of mixed mode or assembly glue.
  451. */
  452. typedef REGISTER_UPP_TYPE(IPMIOCompletionProcPtr)                 IPMIOCompletionUPP;
  453.  
  454. struct IPMOpenContextPB {
  455.     void *                            qLink;
  456.     long                             reservedH1;
  457.     long                             reservedH2;
  458.     IPMIOCompletionUPP                 ioCompletion;
  459.     OSErr                             ioResult;
  460.     long                             saveA5;
  461.     short                             reqCode;
  462.     IPMContextRef                     contextRef;                    /* <--  Context reference to be used in further calls*/
  463. };
  464. typedef struct IPMOpenContextPB            IPMOpenContextPB;
  465.  
  466. typedef IPMOpenContextPB                 IPMCloseContextPB;
  467.  
  468. struct IPMCreateQueuePB {
  469.     void *                            qLink;
  470.     long                             reservedH1;
  471.     long                             reservedH2;
  472.     IPMIOCompletionUPP                 ioCompletion;
  473.     OSErr                             ioResult;
  474.     long                             saveA5;
  475.     short                             reqCode;
  476.     long                             filler1;
  477.     OCERecipient *                    queue;
  478.     AuthIdentity                     identity;                    /* used only if queue is remote */
  479.     PackedRecordID *                owner;                        /* used only if queue is remote */
  480. };
  481. typedef struct IPMCreateQueuePB            IPMCreateQueuePB;
  482. /* For createqueue and deletequeue only queue and identity are used */
  483.  
  484. typedef IPMCreateQueuePB                 IPMDeleteQueuePB;
  485.  
  486. struct IPMOpenQueuePB {
  487.     void *                            qLink;
  488.     long                             reservedH1;
  489.     long                             reservedH2;
  490.     IPMIOCompletionUPP                 ioCompletion;
  491.     OSErr                             ioResult;
  492.     long                             saveA5;
  493.     short                             reqCode;
  494.     IPMContextRef                     contextRef;
  495.     OCERecipient *                    queue;
  496.     AuthIdentity                     identity;
  497.     IPMFilter *                        filter;
  498.     IPMQueueRef                     newQueueRef;
  499.     IPMNoteUPP                         notificationProc;
  500.     unsigned long                     userData;
  501.     IPMNotificationType             noteType;
  502.     Byte                             padByte;
  503.     long                             reserved;
  504.     long                             reserved2;
  505. };
  506. typedef struct IPMOpenQueuePB            IPMOpenQueuePB;
  507.  
  508. struct IPMCloseQueuePB {
  509.     void *                            qLink;
  510.     long                             reservedH1;
  511.     long                             reservedH2;
  512.     IPMIOCompletionUPP                 ioCompletion;
  513.     OSErr                             ioResult;
  514.     long                             saveA5;
  515.     short                             reqCode;
  516.     IPMQueueRef                     queueRef;
  517. };
  518. typedef struct IPMCloseQueuePB            IPMCloseQueuePB;
  519.  
  520. struct IPMEnumerateQueuePB {
  521.     void *                            qLink;
  522.     long                             reservedH1;
  523.     long                             reservedH2;
  524.     IPMIOCompletionUPP                 ioCompletion;
  525.     OSErr                             ioResult;
  526.     long                             saveA5;
  527.     short                             reqCode;
  528.     IPMQueueRef                     queueRef;
  529.     IPMSeqNum                         startSeqNum;
  530.     Boolean                         getProcHint;
  531.     Boolean                         getMsgType;
  532.     short                             filler;
  533.     IPMFilter *                        filter;
  534.     unsigned short                     numToGet;
  535.     unsigned short                     numGotten;
  536.     unsigned long                     enumCount;
  537.     void *                            enumBuffer;                    /* will be packed array of IPMMsgInfo */
  538.     unsigned long                     actEnumCount;
  539. };
  540. typedef struct IPMEnumerateQueuePB        IPMEnumerateQueuePB;
  541.  
  542. typedef IPMEnumerateQueuePB             IPMChangeQueueFilterPB;
  543.  
  544. struct IPMDeleteMsgRangePB {
  545.     void *                            qLink;
  546.     long                             reservedH1;
  547.     long                             reservedH2;
  548.     IPMIOCompletionUPP                 ioCompletion;
  549.     OSErr                             ioResult;
  550.     long                             saveA5;
  551.     short                             reqCode;
  552.     IPMQueueRef                     queueRef;
  553.     IPMSeqNum                         startSeqNum;
  554.     IPMSeqNum                         endSeqNum;
  555.     IPMSeqNum                         lastSeqNum;
  556. };
  557. typedef struct IPMDeleteMsgRangePB        IPMDeleteMsgRangePB;
  558.  
  559.  
  560. struct IPMOpenMsgPB {
  561.     void *                            qLink;
  562.     long                             reservedH1;
  563.     long                             reservedH2;
  564.     IPMIOCompletionUPP                 ioCompletion;
  565.     OSErr                             ioResult;
  566.     long                             saveA5;
  567.     short                             reqCode;
  568.     IPMQueueRef                     queueRef;
  569.     IPMSeqNum                         sequenceNum;
  570.     IPMMsgRef                         newMsgRef;
  571.     IPMSeqNum                         actualSeqNum;
  572.     Boolean                         exactMatch;
  573.     Byte                             padByte;
  574.     long                             reserved;
  575. };
  576. typedef struct IPMOpenMsgPB                IPMOpenMsgPB;
  577.  
  578.  
  579. struct IPMOpenHFSMsgPB {
  580.     void *                            qLink;
  581.     long                             reservedH1;
  582.     long                             reservedH2;
  583.     IPMIOCompletionUPP                 ioCompletion;
  584.     OSErr                             ioResult;
  585.     long                             saveA5;
  586.     short                             reqCode;
  587.     FSSpec *                        hfsPath;
  588.     long                             filler;
  589.     IPMMsgRef                         newMsgRef;
  590.     long                             filler2;
  591.     Byte                             filler3;
  592.     Boolean                         filler4;
  593.     long                             reserved;
  594. };
  595. typedef struct IPMOpenHFSMsgPB            IPMOpenHFSMsgPB;
  596.  
  597.  
  598. struct IPMOpenBlockAsMsgPB {
  599.     void *                            qLink;
  600.     long                             reservedH1;
  601.     long                             reservedH2;
  602.     IPMIOCompletionUPP                 ioCompletion;
  603.     OSErr                             ioResult;
  604.     long                             saveA5;
  605.     short                             reqCode;
  606.     IPMMsgRef                         msgRef;
  607.     unsigned long                     filler;
  608.     IPMMsgRef                         newMsgRef;
  609.     unsigned short                     filler2[7];
  610.     unsigned short                     blockIndex;
  611. };
  612. typedef struct IPMOpenBlockAsMsgPB        IPMOpenBlockAsMsgPB;
  613.  
  614.  
  615. struct IPMCloseMsgPB {
  616.     void *                            qLink;
  617.     long                             reservedH1;
  618.     long                             reservedH2;
  619.     IPMIOCompletionUPP                 ioCompletion;
  620.     OSErr                             ioResult;
  621.     long                             saveA5;
  622.     short                             reqCode;
  623.     IPMMsgRef                         msgRef;
  624.     Boolean                         deleteMsg;
  625.     Boolean                         filler1;
  626. };
  627. typedef struct IPMCloseMsgPB            IPMCloseMsgPB;
  628.  
  629.  
  630. struct IPMGetMsgInfoPB {
  631.     void *                            qLink;
  632.     long                             reservedH1;
  633.     long                             reservedH2;
  634.     IPMIOCompletionUPP                 ioCompletion;
  635.     OSErr                             ioResult;
  636.     long                             saveA5;
  637.     short                             reqCode;
  638.     IPMMsgRef                         msgRef;
  639.     IPMMsgInfo *                    info;
  640. };
  641. typedef struct IPMGetMsgInfoPB            IPMGetMsgInfoPB;
  642.  
  643.  
  644. struct IPMReadHeaderPB {
  645.     void *                            qLink;
  646.     long                             reservedH1;
  647.     long                             reservedH2;
  648.     IPMIOCompletionUPP                 ioCompletion;
  649.     OSErr                             ioResult;
  650.     long                             saveA5;
  651.     short                             reqCode;
  652.     IPMMsgRef                         msgRef;
  653.     unsigned short                     fieldSelector;
  654.     long                             offset;
  655.     unsigned long                     count;
  656.     void *                            buffer;
  657.     unsigned long                     actualCount;
  658.     unsigned short                     filler;
  659.     unsigned long                     remaining;
  660. };
  661. typedef struct IPMReadHeaderPB            IPMReadHeaderPB;
  662.  
  663.  
  664. struct IPMReadRecipientPB {
  665.     void *                            qLink;
  666.     long                             reservedH1;
  667.     long                             reservedH2;
  668.     IPMIOCompletionUPP                 ioCompletion;
  669.     OSErr                             ioResult;
  670.     long                             saveA5;
  671.     short                             reqCode;
  672.     IPMMsgRef                         msgRef;
  673.     unsigned short                     rcptIndex;
  674.     long                             offset;
  675.     unsigned long                     count;
  676.     void *                            buffer;
  677.     unsigned long                     actualCount;
  678.     short                             reserved;                    /* must be zero */
  679.     unsigned long                     remaining;
  680.     unsigned short                     originalIndex;
  681.     OCERecipientOffsetFlags         recipientOffsetFlags;
  682.     Boolean                         filler1;
  683. };
  684. typedef struct IPMReadRecipientPB        IPMReadRecipientPB;
  685.  
  686. /*
  687. replyQueue works like recipient. [can no longer read it via ReadHeader]
  688. OriginalIndex is meaningless, rcptFlags are used seperately and there are
  689. currently none defined.
  690. */
  691.  
  692. typedef IPMReadRecipientPB                 IPMReadReplyQueuePB;
  693.  
  694. struct IPMGetBlkIndexPB {
  695.     void *                            qLink;
  696.     long                             reservedH1;
  697.     long                             reservedH2;
  698.     IPMIOCompletionUPP                 ioCompletion;
  699.     OSErr                             ioResult;
  700.     long                             saveA5;
  701.     short                             reqCode;
  702.     IPMMsgRef                         msgRef;
  703.     IPMBlockType                     blockType;
  704.     unsigned short                     index;
  705.     unsigned short                     startingFrom;
  706.     IPMBlockType                     actualBlockType;
  707.     unsigned short                     actualBlockIndex;
  708. };
  709. typedef struct IPMGetBlkIndexPB            IPMGetBlkIndexPB;
  710.  
  711.  
  712. struct IPMReadMsgPB {
  713.     void *                            qLink;
  714.     long                             reservedH1;
  715.     long                             reservedH2;
  716.     IPMIOCompletionUPP                 ioCompletion;
  717.     OSErr                             ioResult;
  718.     long                             saveA5;
  719.     short                             reqCode;
  720.     IPMMsgRef                         msgRef;
  721.     IPMAccessMode                     mode;
  722.     long                             offset;
  723.     unsigned long                     count;
  724.     void *                            buffer;
  725.     unsigned long                     actualCount;
  726.     unsigned short                     blockIndex;
  727.     unsigned long                     remaining;
  728. };
  729. typedef struct IPMReadMsgPB                IPMReadMsgPB;
  730.  
  731. struct IPMVerifySignaturePB {
  732.     void *                            qLink;
  733.     long                             reservedH1;
  734.     long                             reservedH2;
  735.     IPMIOCompletionUPP                 ioCompletion;
  736.     OSErr                             ioResult;
  737.     long                             saveA5;
  738.     short                             reqCode;
  739.     IPMMsgRef                         msgRef;
  740.     SIGContextPtr                     signatureContext;
  741. };
  742. typedef struct IPMVerifySignaturePB        IPMVerifySignaturePB;
  743.  
  744. struct IPMNewMsgPB {
  745.     void *                            qLink;
  746.     long                             reservedH1;
  747.     long                             reservedH2;
  748.     IPMIOCompletionUPP                 ioCompletion;
  749.     OSErr                             ioResult;
  750.     long                             saveA5;
  751.     short                             reqCode;
  752.     unsigned long                     filler;
  753.     OCERecipient *                    recipient;
  754.     OCERecipient *                    replyQueue;
  755.     StringPtr                         procHint;
  756.     unsigned short                     filler2;
  757.     IPMMsgType *                    msgType;
  758.     unsigned long                     refCon;
  759.     IPMMsgRef                         newMsgRef;
  760.     unsigned short                     filler3;
  761.     long                             filler4;
  762.     AuthIdentity                     identity;
  763.     IPMSender *                        sender;
  764.     unsigned long                     internalUse;
  765.     unsigned long                     internalUse2;
  766. };
  767. typedef struct IPMNewMsgPB                IPMNewMsgPB;
  768.  
  769. struct IPMNewHFSMsgPB {
  770.     void *                            qLink;
  771.     long                             reservedH1;
  772.     long                             reservedH2;
  773.     IPMIOCompletionUPP                 ioCompletion;
  774.     OSErr                             ioResult;
  775.     long                             saveA5;
  776.     short                             reqCode;
  777.     FSSpec *                        hfsPath;
  778.     OCERecipient *                    recipient;
  779.     OCERecipient *                    replyQueue;
  780.     StringPtr                         procHint;
  781.     unsigned short                     filler2;
  782.     IPMMsgType *                    msgType;
  783.     unsigned long                     refCon;
  784.     IPMMsgRef                         newMsgRef;
  785.     unsigned short                     filler3;
  786.     long                             filler4;
  787.     AuthIdentity                     identity;
  788.     IPMSender *                        sender;
  789.     unsigned long                     internalUse;
  790.     unsigned long                     internalUse2;
  791. };
  792. typedef struct IPMNewHFSMsgPB            IPMNewHFSMsgPB;
  793.  
  794. struct IPMNestMsgPB {
  795.     void *                            qLink;
  796.     long                             reservedH1;
  797.     long                             reservedH2;
  798.     IPMIOCompletionUPP                 ioCompletion;
  799.     OSErr                             ioResult;
  800.     long                             saveA5;
  801.     short                             reqCode;
  802.     IPMMsgRef                         msgRef;
  803.     unsigned short                     filler[9];
  804.     unsigned long                     refCon;
  805.     IPMMsgRef                         msgToNest;
  806.     unsigned short                     filler2;
  807.     long                             startingOffset;
  808. };
  809. typedef struct IPMNestMsgPB                IPMNestMsgPB;
  810.  
  811.  
  812. struct IPMNewNestedMsgBlockPB {
  813.     void *                            qLink;
  814.     long                             reservedH1;
  815.     long                             reservedH2;
  816.     IPMIOCompletionUPP                 ioCompletion;
  817.     OSErr                             ioResult;
  818.     long                             saveA5;
  819.     short                             reqCode;
  820.     IPMMsgRef                         msgRef;
  821.     OCERecipient *                    recipient;
  822.     OCERecipient *                    replyQueue;
  823.     StringPtr                         procHint;
  824.     unsigned short                     filler1;
  825.     IPMMsgType *                    msgType;
  826.     unsigned long                     refCon;
  827.     IPMMsgRef                         newMsgRef;
  828.     unsigned short                     filler2;
  829.     long                             startingOffset;
  830.     AuthIdentity                     identity;
  831.     IPMSender *                        sender;
  832.     unsigned long                     internalUse;
  833.     unsigned long                     internalUse2;
  834. };
  835. typedef struct IPMNewNestedMsgBlockPB    IPMNewNestedMsgBlockPB;
  836.  
  837.  
  838. struct IPMEndMsgPB {
  839.     void *                            qLink;
  840.     long                             reservedH1;
  841.     long                             reservedH2;
  842.     IPMIOCompletionUPP                 ioCompletion;
  843.     OSErr                             ioResult;
  844.     long                             saveA5;
  845.     short                             reqCode;
  846.     IPMMsgRef                         msgRef;
  847.     IPMMsgID                         msgID;
  848.     RString *                        msgTitle;
  849.     IPMNotificationType             deliveryNotification;
  850.     IPMPriority                     priority;
  851.     Boolean                         cancel;
  852.     Byte                             padByte;
  853.     long                             reserved;
  854.     SIGSignaturePtr                 signature;
  855.     Size                             signatureSize;
  856.     SIGContextPtr                     signatureContext;
  857.                                                                 /* family this msg belongs (e.g. mail) use kIPMFamilyUnspecified by default */
  858.     OSType                             family;
  859. };
  860. typedef struct IPMEndMsgPB                IPMEndMsgPB;
  861.  
  862.  
  863. struct IPMAddRecipientPB {
  864.     void *                            qLink;
  865.     long                             reservedH1;
  866.     long                             reservedH2;
  867.     IPMIOCompletionUPP                 ioCompletion;
  868.     OSErr                             ioResult;
  869.     long                             saveA5;
  870.     short                             reqCode;
  871.     IPMMsgRef                         msgRef;
  872.     OCERecipient *                    recipient;
  873.     long                             reserved;
  874. };
  875. typedef struct IPMAddRecipientPB        IPMAddRecipientPB;
  876.  
  877.  
  878. struct IPMAddReplyQueuePB {
  879.     void *                            qLink;
  880.     long                             reservedH1;
  881.     long                             reservedH2;
  882.     IPMIOCompletionUPP                 ioCompletion;
  883.     OSErr                             ioResult;
  884.     long                             saveA5;
  885.     short                             reqCode;
  886.     IPMMsgRef                         msgRef;
  887.     long                             filler;
  888.     OCERecipient *                    replyQueue;
  889. };
  890. typedef struct IPMAddReplyQueuePB        IPMAddReplyQueuePB;
  891.  
  892.  
  893. struct IPMNewBlockPB {
  894.     void *                            qLink;
  895.     long                             reservedH1;
  896.     long                             reservedH2;
  897.     IPMIOCompletionUPP                 ioCompletion;
  898.     OSErr                             ioResult;
  899.     long                             saveA5;
  900.     short                             reqCode;
  901.     IPMMsgRef                         msgRef;
  902.     IPMBlockType                     blockType;
  903.     unsigned short                     filler[5];
  904.     unsigned long                     refCon;
  905.     unsigned short                     filler2[3];
  906.     long                             startingOffset;
  907. };
  908. typedef struct IPMNewBlockPB            IPMNewBlockPB;
  909.  
  910.  
  911. struct IPMWriteMsgPB {
  912.     void *                            qLink;
  913.     long                             reservedH1;
  914.     long                             reservedH2;
  915.     IPMIOCompletionUPP                 ioCompletion;
  916.     OSErr                             ioResult;
  917.     long                             saveA5;
  918.     short                             reqCode;
  919.     IPMMsgRef                         msgRef;
  920.     IPMAccessMode                     mode;
  921.     long                             offset;
  922.     unsigned long                     count;
  923.     void *                            buffer;
  924.     unsigned long                     actualCount;
  925.     Boolean                         currentBlock;
  926.     Boolean                         filler1;
  927. };
  928. typedef struct IPMWriteMsgPB            IPMWriteMsgPB;
  929.  
  930.  
  931.  
  932. union IPMParamBlock {
  933.     struct {
  934.         void *                            qLink;
  935.         long                             reservedH1;
  936.         long                             reservedH2;
  937.         IPMIOCompletionUPP                 ioCompletion;
  938.         OSErr                             ioResult;
  939.         long                             saveA5;
  940.         short                             reqCode;
  941.     }                                 header;
  942.     IPMOpenContextPB                 openContextPB;
  943.     IPMCloseContextPB                 closeContextPB;
  944.     IPMCreateQueuePB                 createQueuePB;
  945.     IPMDeleteQueuePB                 deleteQueuePB;
  946.     IPMOpenQueuePB                     openQueuePB;
  947.     IPMCloseQueuePB                 closeQueuePB;
  948.     IPMEnumerateQueuePB             enumerateQueuePB;
  949.     IPMChangeQueueFilterPB             changeQueueFilterPB;
  950.     IPMDeleteMsgRangePB             deleteMsgRangePB;
  951.     IPMOpenMsgPB                     openMsgPB;
  952.     IPMOpenHFSMsgPB                 openHFSMsgPB;
  953.     IPMOpenBlockAsMsgPB             openBlockAsMsgPB;
  954.     IPMCloseMsgPB                     closeMsgPB;
  955.     IPMGetMsgInfoPB                 getMsgInfoPB;
  956.     IPMReadHeaderPB                 readHeaderPB;
  957.     IPMReadRecipientPB                 readRecipientPB;
  958.     IPMReadReplyQueuePB             readReplyQueuePB;
  959.     IPMGetBlkIndexPB                 getBlkIndexPB;
  960.     IPMReadMsgPB                     readMsgPB;
  961.     IPMVerifySignaturePB             verifySignaturePB;
  962.     IPMNewMsgPB                     newMsgPB;
  963.     IPMNewHFSMsgPB                     newHFSMsgPB;
  964.     IPMNestMsgPB                     nestMsgPB;
  965.     IPMNewNestedMsgBlockPB             newNestedMsgBlockPB;
  966.     IPMEndMsgPB                     endMsgPB;
  967.     IPMAddRecipientPB                 addRecipientPB;
  968.     IPMAddReplyQueuePB                 addReplyQueuePB;
  969.     IPMNewBlockPB                     newBlockPB;
  970.     IPMWriteMsgPB                     writeMsgPB;
  971. };
  972.  
  973. enum { uppIPMIOCompletionProcInfo = 0x00009802 };                 /* register no_return_value Func(4_bytes:A0) */
  974. #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  975.     #pragma parameter CallIPMIOCompletionProc(__A1, __A0)
  976.     void CallIPMIOCompletionProc(IPMIOCompletionUPP routine, IPMParamBlockPtr paramBlock) = 0x4E91;
  977. #else
  978.     #define CallIPMIOCompletionProc(userRoutine, paramBlock)     CALL_ONE_PARAMETER_UPP((userRoutine), uppIPMIOCompletionProcInfo, (paramBlock))
  979. #endif
  980. #define NewIPMIOCompletionProc(userRoutine)                     (IPMIOCompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppIPMIOCompletionProcInfo, GetCurrentArchitecture())
  981. EXTERN_API( OSErr )
  982. IPMOpenContext                    (IPMParamBlockPtr         paramBlock,
  983.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0400, 0xAA5E);
  984.  
  985. EXTERN_API( OSErr )
  986. IPMCloseContext                    (IPMParamBlockPtr         paramBlock,
  987.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0401, 0xAA5E);
  988.  
  989. EXTERN_API( OSErr )
  990. IPMNewMsg                        (IPMParamBlockPtr         paramBlock,
  991.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0402, 0xAA5E);
  992.  
  993. EXTERN_API( OSErr )
  994. IPMNewBlock                        (IPMParamBlockPtr         paramBlock,
  995.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0404, 0xAA5E);
  996.  
  997. EXTERN_API( OSErr )
  998. IPMNewNestedMsgBlock            (IPMParamBlockPtr         paramBlock,
  999.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0405, 0xAA5E);
  1000.  
  1001. EXTERN_API( OSErr )
  1002. IPMNestMsg                        (IPMParamBlockPtr         paramBlock,
  1003.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0406, 0xAA5E);
  1004.  
  1005. EXTERN_API( OSErr )
  1006. IPMWriteMsg                        (IPMParamBlockPtr         paramBlock,
  1007.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0407, 0xAA5E);
  1008.  
  1009. EXTERN_API( OSErr )
  1010. IPMEndMsg                        (IPMParamBlockPtr         paramBlock,
  1011.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0408, 0xAA5E);
  1012.  
  1013. EXTERN_API( OSErr )
  1014. IPMOpenQueue                    (IPMParamBlockPtr         paramBlock,
  1015.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0409, 0xAA5E);
  1016.  
  1017. EXTERN_API( OSErr )
  1018. IPMCloseQueue                    (IPMParamBlockPtr         paramBlock,
  1019.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x040A, 0xAA5E);
  1020.  
  1021. /* Always synchronous */
  1022. EXTERN_API( OSErr )
  1023. IPMVerifySignature                (IPMParamBlockPtr         paramBlock)                            FIVEWORDINLINE(0x7000, 0x1F00, 0x3F3C, 0x0422, 0xAA5E);
  1024.  
  1025. EXTERN_API( OSErr )
  1026. IPMOpenMsg                        (IPMParamBlockPtr         paramBlock,
  1027.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x040B, 0xAA5E);
  1028.  
  1029. EXTERN_API( OSErr )
  1030. IPMCloseMsg                        (IPMParamBlockPtr         paramBlock,
  1031.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x040C, 0xAA5E);
  1032.  
  1033. EXTERN_API( OSErr )
  1034. IPMReadMsg                        (IPMParamBlockPtr         paramBlock,
  1035.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x040D, 0xAA5E);
  1036.  
  1037. EXTERN_API( OSErr )
  1038. IPMReadHeader                    (IPMParamBlockPtr         paramBlock,
  1039.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x040E, 0xAA5E);
  1040.  
  1041. EXTERN_API( OSErr )
  1042. IPMOpenBlockAsMsg                (IPMParamBlockPtr         paramBlock,
  1043.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x040F, 0xAA5E);
  1044.  
  1045. EXTERN_API( OSErr )
  1046. IPMNewHFSMsg                    (IPMParamBlockPtr         paramBlock,
  1047.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x041E, 0xAA5E);
  1048.  
  1049. EXTERN_API( OSErr )
  1050. IPMReadRecipient                (IPMParamBlockPtr         paramBlock,
  1051.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0410, 0xAA5E);
  1052.  
  1053. EXTERN_API( OSErr )
  1054. IPMReadReplyQueue                (IPMParamBlockPtr         paramBlock,
  1055.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0421, 0xAA5E);
  1056.  
  1057. EXTERN_API( OSErr )
  1058. IPMCreateQueue                    (IPMParamBlockPtr         paramBlock,
  1059.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0411, 0xAA5E);
  1060.  
  1061. EXTERN_API( OSErr )
  1062. IPMDeleteQueue                    (IPMParamBlockPtr         paramBlock,
  1063.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0412, 0xAA5E);
  1064.  
  1065. EXTERN_API( OSErr )
  1066. IPMEnumerateQueue                (IPMParamBlockPtr         paramBlock,
  1067.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0413, 0xAA5E);
  1068.  
  1069. EXTERN_API( OSErr )
  1070. IPMChangeQueueFilter            (IPMParamBlockPtr         paramBlock,
  1071.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0414, 0xAA5E);
  1072.  
  1073. EXTERN_API( OSErr )
  1074. IPMDeleteMsgRange                (IPMParamBlockPtr         paramBlock,
  1075.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0415, 0xAA5E);
  1076.  
  1077. EXTERN_API( OSErr )
  1078. IPMAddRecipient                    (IPMParamBlockPtr         paramBlock,
  1079.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0403, 0xAA5E);
  1080.  
  1081. EXTERN_API( OSErr )
  1082. IPMAddReplyQueue                (IPMParamBlockPtr         paramBlock,
  1083.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x041D, 0xAA5E);
  1084.  
  1085. EXTERN_API( OSErr )
  1086. IPMOpenHFSMsg                    (IPMParamBlockPtr         paramBlock,
  1087.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0417, 0xAA5E);
  1088.  
  1089. EXTERN_API( OSErr )
  1090. IPMGetBlkIndex                    (IPMParamBlockPtr         paramBlock,
  1091.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0418, 0xAA5E);
  1092.  
  1093. EXTERN_API( OSErr )
  1094. IPMGetMsgInfo                    (IPMParamBlockPtr         paramBlock,
  1095.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0419, 0xAA5E);
  1096.  
  1097.  
  1098.  
  1099.  
  1100. #if PRAGMA_STRUCT_ALIGN
  1101.     #pragma options align=reset
  1102. #elif PRAGMA_STRUCT_PACKPUSH
  1103.     #pragma pack(pop)
  1104. #elif PRAGMA_STRUCT_PACK
  1105.     #pragma pack()
  1106. #endif
  1107.  
  1108. #ifdef PRAGMA_IMPORT_OFF
  1109. #pragma import off
  1110. #elif PRAGMA_IMPORT
  1111. #pragma import reset
  1112. #endif
  1113.  
  1114. #ifdef __cplusplus
  1115. }
  1116. #endif
  1117.  
  1118. #endif /* __OCEMESSAGING__ */
  1119.  
  1120.